package com.example.demo1;

//import jdk.nashorn.internal.runtime.Undefined;
import org.springframework.util.StringUtils;

import java.beans.PropertyEditorSupport;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;

/**
 * @Description 类描述：时间操作定义类
 * @Date 2019/4/22 11:16
 * @Author taogang
 * @Version v1.0
 **/
public class DateUtils extends PropertyEditorSupport {

	public static final String PATTERN_YYYY_MM = "yyyy-MM";

	public static final String PATTERN_YYYY_MM_DD = "yyyy-MM-dd";

	public static final String PATTERN_YYYYMMDDHHMMSS = "yyyyMMddHHmmss";

	public static final String PATTERN_UNIT_YYYY_MM_DD = "yyyy年-MM月-dd日";

	public static final String PATTERN_UNIT_MM_DD = "MM月-dd日";

	public static final String PATTERN_YYYYMMDDOT = "yyyy.MM.dd";

	public static final String PATTERN_UNIT_YYYYMMDD = "yyyy年MM月dd日";

	public static final String DATE_FORMAT_YYYYMMDD = "yyyy-MM-dd";

	public static final String DATE_FORMAT_YYYYMMDDHHMMSS = "yyyy-MM-dd HH:mm:ss";

	public static final String PATTERN_YYYY = "yyyy";

	private static final Integer TEN = 10;

	private static final Integer NINETEEN = 19;

	private static final String COLON = ":";

	/**
	 * 其他时间值转换为毫秒单位：秒
	 */
	private static final long UNIT_SECOND_TIME = 1000;

	/**
	 * 其他时间值转换为毫秒单位：分钟
	 */
	private static final long UNIT_MINUS_TIME = 60 * UNIT_SECOND_TIME;

	/**
	 * 其他时间值转换为毫秒单位：小时
	 */
	private static final long UNIT_HOUR_TIME = 60 * UNIT_MINUS_TIME;

	/**
	 * 其他时间值转换为毫秒单位：天
	 */
	private static final long UNIT_DAY_TIME = 24 * UNIT_HOUR_TIME;

	private static final SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");

	private static final SimpleDateFormat SIMPLE_DATE_FORMAT1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");

	private static final SimpleDateFormat SIMPLE_DATE_FORMAT2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	/**
	 * 日期格式化模式（时间类型数据）
	 * <p>
	 * 日期格式化模式，使用此模式将日期格式化为“2012-10-08 10:10:08”，一般用于时间类型数据格式化
	 * </p>
	 */
	public static final String PATTERN_YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";

	/**
	 * 当前日历，这里用中国时间表示
	 *
	 * @return 以当地时区表示的系统当前日历
	 */
	public static Calendar getCalendar() {
		return Calendar.getInstance();
	}

	/**
	 * 当前日期
	 *
	 * @return 系统当前时间
	 */
	public static Date getDate() {
		return new Date();
	}

	/**
	 * 指定毫秒数表示的日期
	 *
	 * @param millis 毫秒数
	 * @return 指定毫秒数表示的日期
	 */
	public static Date getDate(long millis) {
		return new Date(millis);
	}

	/**
	 * 日期格式化模式（时间类型数据），精确到分
	 * <p>
	 * 日期格式化模式，使用此模式将日期格式化为“2012-10-08 10:10”，一般用于时间类型数据格式化
	 * </p>
	 */
	public static final String PATTERN_YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";

	/**
	 * 格式化时间
	 */
	public static String dateformat(String date, String format) {
		SimpleDateFormat sformat = new SimpleDateFormat(format);
		Date o = null;
		try {
			o = sformat.parse(date);
		}
		catch (ParseException e) {
			e.printStackTrace();
		}
		return sformat.format(o);
	}

	/**
	 * 日期转换为字符串
	 *
	 * @param format 日期格式
	 * @return 字符串
	 */
	public static String getDate(String format) {
		Date date = new Date();
		if (null == date) {
			return null;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return sdf.format(date);
	}

	/**
	 * 系统当前的时间戳
	 *
	 * @return 系统当前的时间戳
	 */
	public static Timestamp getTimestamp() {
		return new Timestamp(System.currentTimeMillis());
	}

	/**
	 * 默认日期按指定格式显示
	 *
	 * @param pattern 指定的格式
	 * @return 默认日期按指定格式显示
	 */
	public static String formatDate(String pattern) {
		return getSDFormat(pattern).format(getCalendar().getTime());
	}

	/**
	 * 指定日期按指定格式显示
	 *
	 * @param cal     指定的日期
	 * @param pattern 指定的格式
	 * @return 指定日期按指定格式显示
	 */
	public static String formatDate(Calendar cal, String pattern) {
		return getSDFormat(pattern).format(cal.getTime());
	}

	/**
	 * 指定日期按指定格式显示
	 *
	 * @param date    指定的日期
	 * @param pattern 指定的格式
	 * @return 指定日期按指定格式显示
	 */
	public static String formatDate(Date date, String pattern) {
		if (date != null) {
			return getSDFormat(pattern).format(date);
		} else {
			return "";
		}

	}

	/**
	 * 默认方式表示的系统当前日期，具体格式：年-月-日 时：分
	 *
	 * @return 默认日期按“年-月-日 时：分“格式显示
	 */
	public synchronized static String formatTime() {
		return SIMPLE_DATE_FORMAT1.format(getCalendar().getTime());
	}

	/**
	 * 指定毫秒数表示日期的默认显示，具体格式：年-月-日 时：分
	 *
	 * @param millis 指定的毫秒数
	 * @return 指定毫秒数表示日期按“年-月-日 时：分“格式显示
	 */
	public synchronized static String formatTime(long millis) {
		return SIMPLE_DATE_FORMAT1.format(new Date(millis));
	}

	/**
	 * 指定日期的默认显示，具体格式：年-月-日 时：分
	 *
	 * @param cal 指定的日期
	 * @return 指定日期按“年-月-日 时：分“格式显示
	 */
	public synchronized static String formatTime(Calendar cal) {
		return SIMPLE_DATE_FORMAT1.format(cal.getTime());
	}

	/**
	 * 指定日期的默认显示，具体格式：年-月-日 时：分
	 *
	 * @param date 指定的日期
	 * @return 指定日期按“年-月-日 时：分“格式显示
	 */
	public synchronized static String formatTime(Date date) {
		return SIMPLE_DATE_FORMAT1.format(date);
	}

	/**
	 * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
	 *
	 * @param src     将要转换的原始字符窜
	 * @param pattern 转换的匹配格式
	 * @return 如果转换成功则返回转换后的日期
	 */
	public static Date parseDate(String src, String pattern)
			throws ParseException {
		return getSDFormat(pattern).parse(src);

	}

	/**
	 * @Description 获得当前日期的年
	 * @Date 2019/4/22 11:14
	 * @Author taogang
	 * @Version v1.0
	 **/
	public static int getYear() {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(getDate());
		return calendar.get(Calendar.YEAR);
	}

	/**
	 * @Description 获得当前日期的年
	 * @Date 2019/4/22 11:15
	 * @Author taogang
	 * @Version v1.0
	 **/
	public static int getMonth() {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(new Date());
		return calendar.get(Calendar.MONTH) + 1;
	}

	/**
	 * @Description 获得当前日期的年
	 * @Date 2019/4/22 11:15
	 * @Author taogang
	 * @Version v1.0
	 **/
	public static int getDay() {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(new Date());
		return calendar.get(Calendar.DATE);
	}


	/**
	 * @Description 指定模式的时间格式
	 * @Date 2019/4/22 11:15
	 * @Author taogang
	 * @Version v1.0
	 **/
	private static SimpleDateFormat getSDFormat(String pattern) {
		return new SimpleDateFormat(pattern);
	}

	/**
	 * 默认方式表示的系统当前日期，具体格式：年-月-日
	 *
	 * @return 默认日期按“年-月-日“格式显示
	 */
	public synchronized static String formatDate() {
		return SIMPLE_DATE_FORMAT.format(getCalendar().getTime());
	}

	/**
	 * 指定日期的默认显示，具体格式：年-月-日
	 *
	 * @param cal 指定的日期
	 * @return 指定日期按“年-月-日“格式显示
	 */
	public synchronized static String formatDate(Calendar cal) {
		return SIMPLE_DATE_FORMAT.format(cal.getTime());
	}

	/**
	 * 指定日期的默认显示，具体格式：年-月-日
	 *
	 * @param date 指定的日期
	 * @return 指定日期按“年-月-日“格式显示
	 */
	public synchronized static String formatDate(Date date) {
		return SIMPLE_DATE_FORMAT.format(date);
	}

	/**
	 * 指定毫秒数表示日期的默认显示，具体格式：年-月-日
	 *
	 * @param millis 指定的毫秒数
	 * @return 指定毫秒数表示日期按“年-月-日“格式显示
	 */
	public synchronized static String formatDate(long millis) {
		return SIMPLE_DATE_FORMAT.format(new Date(millis));
	}

	/**
	 * @Description 比较两个时间的大小 参数1时间在参数2时间之前 ,返回true,否则返回false Date 或者String类型
	 * @Param beginDate 开始日期  endDate 结束日期
	 * @Return
	 * @Date 2017/9/20 11:57
	 * @Author Taogang
	 */
	public static boolean compareDate(Object beginDate, Object endDate) throws ParseException {
		if (beginDate == null || endDate == null ) {
			return false;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(PATTERN_YYYY_MM_DD);
		Date nowBegin = null, nowEnd = null;
		if (beginDate instanceof Date && endDate instanceof Date) {
			nowBegin = (Date) beginDate;
			nowEnd = (Date) endDate;
		}
		if (beginDate instanceof String && endDate instanceof String) {
			nowBegin = sdf.parse(String.valueOf(beginDate));
			nowEnd = sdf.parse(String.valueOf(endDate));
		}
		if (nowBegin!=null && nowEnd!=null) {
			return nowBegin.getTime() < nowEnd.getTime();
		}
		return false;
	}

	/**
	 * @Description 获取当前日期之前之后天数的日期
	 * @Param pattern 日期format  days 正之后 负之前
	 * @Return
	 * @Date 2017/9/20 11:53
	 * @Author Taogang
	 */
	public static Date getDateAfterDays(String pattern, int days) {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		Date date = new Date();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_YEAR, days);
		return calendar.getTime();
	}

	/**
	 * @Description 获取当前时间(年份)之前之后的年份时间
	 * @Param years 年份 负数之前,正数之后 如-1 代表去年当前这个时间
	 * @Return
	 * @Date 2017/9/19 14:12
	 * @Author Taogang
	 */
	public static Date getDateAfterYears(int years) {
		Calendar calendar = Calendar.getInstance();
		Date date = new Date(System.currentTimeMillis());
		calendar.setTime(date);
		calendar.add(Calendar.YEAR, years);
		return calendar.getTime();
	}

	/**
	 * @Description 获取 时间(年份)之前之后的年份时间
	 * @Param years 年份 负数之前,正数之后 如-1 代表去年当前这个时间
	 * @Return
	 * @Date 2017/9/19 14:12
	 * @Author Taogang
	 */
	public static Date getAfterYears(Date date, int years) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.YEAR, years);
		return calendar.getTime();
	}

	/**
	 * @Description 根据出生日期或取年龄
	 * @Param
	 * @Return
	 * @Date 2017/9/19 12:01
	 * @Author Taogang
	 */
	public static String getAge(Object day) {
		if (day == null ) {
			return null;
		}
		Date birthDay = null;
		Calendar cal = Calendar.getInstance();
		int yearNow = cal.get(Calendar.YEAR);
		int monthNow = cal.get(Calendar.MONTH);
		int dayOfMonthNow = cal.get(Calendar.DAY_OF_MONTH);
		if (day instanceof String) {
			birthDay = strFormatDate(String.valueOf(day), PATTERN_YYYY_MM_DD);
			cal.setTime(birthDay);
		}
		if (day instanceof Date) {
			birthDay = (Date) day;
			cal.setTime(birthDay);
		}
		if (cal.before(birthDay)) {
			throw new IllegalArgumentException("The birthDay is before Now.It's unbelievable!");
		}
		int yearBirth = cal.get(Calendar.YEAR);
		int monthBirth = cal.get(Calendar.MONTH);
		int dayOfMonthBirth = cal.get(Calendar.DAY_OF_MONTH);
		int age = yearNow - yearBirth;
		if (monthNow <= monthBirth) {
			if (monthNow == monthBirth) {
				if (dayOfMonthNow < dayOfMonthBirth) {
					age--;
				}
			} else {
				age--;
			}
		}
		return String.valueOf(age);
	}

	/**
	 * 根据特定模式，将字符串型日期对象解析成Date对象
	 *
	 * @param source  要解析的字符串
	 * @param pattern 解析模式，默认为{@value #PATTERN_YYYY_MM_DD_HH_MM_SS}
	 * @return 解析结果
	 * @throws ParseException 如果要解析的字符串格式不匹配，则抛出此异常
	 */
	public static Date parse(final String source, String pattern) {
		try {
			if (source == null || org.apache.commons.lang.StringUtils.isBlank(source)) {
				return null;
			}
			if (pattern == null) {
				pattern = PATTERN_YYYY_MM_DD_HH_MM_SS;
			}
			return new SimpleDateFormat(pattern).parse(source);
		}
		catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 将日期对象根据特定格式格式化成字符串
	 *
	 * @param source  要格式化的日期对象
	 * @param pattern 格式化模式，默认为{@value #PATTERN_YYYY_MM_DD_HH_MM_SS}
	 * @return 格式化后的字符串
	 */
	public static String format(final Date source, String pattern) {
		// 检查value是否为空
		if (source == null) {
			return null;
		}
		// 如果pattern为空
		if (pattern == null) {
			// 设置pattern为PATTERN_YYYY_MM_DD_HH_MM_SS
			pattern = PATTERN_YYYY_MM_DD_HH_MM_SS;
		}
		// 初始化一个format类
		SimpleDateFormat format = new SimpleDateFormat(pattern);
		return format.format(source);
	}

	/**
	 * 格式化到天
	 */
	public static String formatToDay(final Date source) {

		return format(source, PATTERN_YYYY_MM_DD);
	}

	/**
	 * 返回服务器时间
	 */
	public static Date getServerDate() {
		return new Date();
	}

	/**
	 * 获取日期相对于1970/01/01的时间戳
	 *
	 * @param source 要比较的时间
	 * @return 时间戳
	 */
	public static long getTime(final Date source) {
		if (source == null) {
			return -1;
		}
		return source.getTime();
	}

	/**
	 * 特定日期1  和  特定日期2  相差的天数
	 *
	 * @return 天数，之后大于零，之前小于零
	 */
	public static int daysBefore(final Date source1, final Date source2) {
		// 如果要比较的source不存在
		if (source1 == null || source2 == null) {
			return 0;
		}
		Calendar now = Calendar.getInstance();
		Calendar old = Calendar.getInstance();
		// 设置时分秒为0:0:0
		old.setTime(source1);
		old.set(Calendar.HOUR_OF_DAY, 0);
		old.set(Calendar.MINUTE, 0);
		old.set(Calendar.SECOND, 0);

		now.setTime(source2);
		now.set(Calendar.HOUR_OF_DAY, 0);
		now.set(Calendar.MINUTE, 0);
		now.set(Calendar.SECOND, 0);
		// 获取相差描述
		long l = old.getTimeInMillis() - now.getTimeInMillis();
		// 转换程天数
		return BigDecimal
				.valueOf(l)
				.divide(BigDecimal.valueOf(UNIT_DAY_TIME), RoundingMode.HALF_UP)
				.intValue();
	}

	/**
	 * 特定日期1  和  特定日期2  相差的天数
	 *
	 * @return 天数，之后大于零，之前小于零
	 */
	public static int daysBeforeSECOND(final Date source1, final Date source2) {
		// 如果要比较的source不存在
		if (source1 == null || source2 == null) {
			return 0;
		}
		Calendar now = Calendar.getInstance();
		Calendar old = Calendar.getInstance();
		old.setTime(source1);
		now.setTime(source2);

		// 获取相差描述
		long l = old.getTimeInMillis() - now.getTimeInMillis();
		// 转换程天数
		return BigDecimal
				.valueOf(l)
				.divide(BigDecimal.valueOf(UNIT_DAY_TIME), RoundingMode.DOWN)
				.intValue();
	}

	/**
	 * 获取在某天的基础上增加或减少N天
	 *
	 * @param date 某天
	 */
	public static Date getDateAfterDays(Date date, int days) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.add(Calendar.DAY_OF_YEAR, days);
		return c.getTime();
	}

	/**
	 * 获取在某天的基础上增加或减少N月
	 *
	 * @param date   某天
	 * @param months 加上或减少的月数，正数为加，负数为减。
	 */
	public static Date getDateAfterMonths(Date date, int months) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.add(Calendar.MONTH, months);
		return c.getTime();
	}

	/**
	 */
	public static Date getDateAfterYears(Date date, int days) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.add(Calendar.YEAR, days);
		return c.getTime();
	}

	/**
	 * 在当前时间的基础上添加特定时间
	 * <p>
	 * 根据type类型来区分添加的时间单位，type等同于Calendar.XXXX 如：小时Calendar.HOUR_OF_DAY。<br/> 暂只支持，DAY_OF_MONTH,HOUR_OF_DAY，MINUTE
	 * </p>
	 *
	 * @param type  类型
	 * @param value 要新增的值（如果是负数则是减少的值）
	 * @return 处理后的时间
	 */
	public static Date addByCurrent(int type, int value) {
		return addByDate(new Date(), type, value);
	}

	/**
	 * 在特定时间的基础上添加特定时间
	 * <p>
	 * 根据type类型来区分添加的时间单位，type等同于Calendar.XXXX 如：小时Calendar.HOUR_OF_DAY。<br/> 暂只支持，DAY_OF_MONTH,HOUR_OF_DAY，MINUTE
	 * </p>
	 *
	 * @param date  特定时间
	 * @param type  类型
	 * @param value 要新增的值（如果是负数则是减少的值）
	 * @return 处理后的时间
	 */
	public static Date addByDate(Date date, int type, int value) {
		Calendar now = Calendar.getInstance();
		now.setTime(date);
		now.add(type, value);
		return now.getTime();
	}

	/**
	 * 同oracle：add_months函数
	 */
	public static Date addMonths(Date date, int months) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		Calendar caltem = Calendar.getInstance();
		caltem.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH) + months, 1);
		int maxday = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
		int today = cal.get(Calendar.DATE);
		int lastday = caltem.getActualMaximum(Calendar.DAY_OF_MONTH);
		if (today == maxday || today > lastday) {
			caltem.set(Calendar.DAY_OF_MONTH, lastday);
		} else {
			caltem.set(Calendar.DAY_OF_MONTH, today);
		}
		return caltem.getTime();
	}

	/**
	 * 检查两个日期的某个单位的差值，当前支持小时、天数
	 *
	 * @param before 被减数
	 * @param after  减数
	 * @param type   类型，参见Calendar
	 * @return 值
	 */
	public static int distance(Date before, Date after, int type) {
		if (before == null || after == null) {
			throw new IllegalArgumentException("参数值错误");
		}
		Calendar start = Calendar.getInstance();
		start.setTime(before);
		Calendar end = Calendar.getInstance();
		end.setTime(after);

		long unit = -1;
		switch (type) {
			case Calendar.DAY_OF_MONTH:
				end.set(Calendar.HOUR_OF_DAY, 0);
				start.set(Calendar.HOUR_OF_DAY, 0);
				unit = UNIT_DAY_TIME;
				break;
			case Calendar.HOUR_OF_DAY:
				unit = UNIT_HOUR_TIME;
				//设置分秒
				end.set(Calendar.SECOND, 0);
				end.set(Calendar.MINUTE, 0);
				start.set(Calendar.SECOND, 0);
				start.set(Calendar.MINUTE, 0);
				break;
			case Calendar.MINUTE:
				unit = UNIT_MINUS_TIME;
				//设置分秒
				end.set(Calendar.SECOND, 0);
				start.set(Calendar.SECOND, 0);
				break;
			case Calendar.SECOND:
				unit = UNIT_SECOND_TIME;
				break;
			default:
				throw new IllegalArgumentException("type = " + type + " no support !!!!");
		}
		return BigDecimal
				.valueOf(start.getTimeInMillis() - end.getTimeInMillis())
				.divide(BigDecimal.valueOf(unit), RoundingMode.HALF_UP)
				.intValue();
	}

	/**
	 * @Description 两个日期之间小时数(保留一位小数)
	 * @Author Taogang
	 * @Date 2018/5/22 17:18
	 * @Version V1.0
	 */
	public static double distanceDateForHour(Date before, Date after) {
		if (before == null || after == null) {
			throw new IllegalArgumentException("参数值错误");
		}
		return BigDecimal.valueOf((float) (before.getTime() - after.getTime()) / (1000 * 3600)).setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
	}

	/**
	 * 获取当前日期
	 */
	public static Date getCurrentDate(String pattern) {
		String sToday = format(new Date(), pattern);
		return parse(sToday, pattern);
	}

	/**
	 * 获得指定日期所在周的第一天
	 */
	public static Date getFirstDayOfWeek(Date date) {
		Calendar c = new GregorianCalendar();
		c.setFirstDayOfWeek(Calendar.MONDAY);
		c.setTime(date);
		c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());
		return c.getTime();
	}

	/**
	 * 根据日期取得月份
	 */
	public static String getMonth(Date date) {
		String[] months = { "一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月" };
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int i = cal.get(Calendar.MONTH);
		if (i < 0) {
			i = 0;
		}
		return months[i];
	}

	/**
	 * @Description 时间转字符
	 * @Date 2019/4/22 11:15
	 * @Author taogang
	 * @Version v1.0
	 **/
	public static String dateFormatStr(Date de, String format) {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return sdf.format(de);
	}

	public static String dateFormatStrEn(Date date, String format) {
		SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.ENGLISH);
		return sdf.format(date);
	}

	/**
	 * @Description 字符串转时间
	 * @Date 2019/4/22 11:15
	 * @Author taogang
	 * @Version v1.0
	 **/
	public static Date strFormatDate(String sDate, String format) {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		Date date = null;
		try {
			date = sdf.parse(sDate);
		}
		catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}

	/**
	 * 两个时间相差天数
	 *
	 * @param start 开始时间
	 * @param end   结束时间
	 */
	public static long betweenDay(Date start, Date end) {
		return ((end.getTime() - start.getTime()) / 3600 / 24 / 1000);
//        return Math.abs (end.getTime() - start.getTime()) / 3600 / 24 / 1000;
	}

	/**
	 * 获取当前日期月份最后一天
	 */
	public static String lastDayOfMonth(Date date, String format) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		int value = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
		cal.set(Calendar.DAY_OF_MONTH, value);
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return sdf.format(cal.getTime());
	}

	/**
	 * @Description 将时间戳转换为时间
	 * @Date 2019/4/22 11:15
	 * @Author taogang
	 * @Version v1.0
	 **/
	public static String stampToDate(String s) {
		try {
			SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
			long lt = new Long(s);
			Date date = new Date(lt);
			String str = simpleDateFormat.format(date);
			if (str != null && str.length() > TEN) {
				str = str.substring(0, TEN);
			}
			return str;
		}
		catch (Exception e) {
			if (s != null && s.length() > TEN) {
				s = s.substring(0, TEN);
			}
			return s;
		}
	}

	/**
	 * 获取当前年
	 */
	public static String getCurYear() {
		SimpleDateFormat format = new SimpleDateFormat("yyyy");
		return format.format(new Date());
	}

	/**
	 * String类型 转换为Date, 如果参数长度为10 转换格式”yyyy-MM-dd“ 如果参数长度为19 转换格式”yyyy-MM-dd HH:mm:ss“ * @param text String类型的时间值
	 */
	@Override
	public void setAsText(String text) throws IllegalArgumentException {
		if (StringUtils.hasText(text)) {
			try {
				if (text.indexOf(COLON) == -1 && text.length() == TEN) {
					setValue(SIMPLE_DATE_FORMAT.parse(text));
				} else if (text.indexOf(COLON) > 0 && text.length() == NINETEEN) {
					setValue(SIMPLE_DATE_FORMAT2.parse(text));
				} else {
					throw new IllegalArgumentException(
							"Could not parse date, date format is error ");
				}
			}
			catch (ParseException ex) {
				IllegalArgumentException iae = new IllegalArgumentException(
						"Could not parse date: " + ex.getMessage(), ex);
				throw iae;
			}
		} else {
			setValue(null);
		}
	}

	/**
	 * @Description velocity打印模板日期格式化
	 * @Author xujiaming
	 * @Date 2019/3/7 10:17
	 */
	public String format(String pattern, final Date source) {
		// 检查value是否为空
		if (source == null) {
			return null;
		}
		// 如果pattern为空
		if (pattern == null) {
			// 设置pattern为PATTERN_YYYY_MM_DD_HH_MM_SS
			pattern = PATTERN_YYYY_MM_DD_HH_MM_SS;
		}
		// 初始化一个format类
		SimpleDateFormat format = new SimpleDateFormat(pattern);
		return format.format(source);
	}

	public static String DateDiff(Date data1,Date date2){
		long nd = 1000 * 24 * 60 * 60;
		long nh = 1000 * 60 * 60;
		long nm = 1000 * 60;
		long ns = 1000;
		// long ns = 1000;
		// 获得两个时间的毫秒时间差异
		long diff = data1.getTime()-date2.getTime();
		// 计算差多少天
		long day = diff / nd;
		// 计算差多少小时
		long hour = diff % nd / nh;
		// 计算差多少分钟
		long min = diff % nd % nh / nm;
		// 计算差多少秒钟
		long second = diff % nd % nh % nm / ns;

		return day+"天"+hour+"小时"+min+"分钟"+second+"秒";
	}
}